home *** CD-ROM | disk | FTP | other *** search
/ 3D Games - Real-time Rend…ng & Software Technology / 3D Games - Real-time Rendering & Software Technology.iso / flysdk / util / max / landscape / landscape.cpp next >
Encoding:
C/C++ Source or Header  |  1999-10-18  |  14.2 KB  |  641 lines
  1. #include "landscape.h"
  2.  
  3. ClassDesc* GetlandscapeDesc();
  4.  
  5. HINSTANCE hInstance;
  6. int controlsInit = FALSE;
  7.  
  8. BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG fdwReason,LPVOID lpvReserved)
  9. {
  10.     hInstance = hinstDLL;                // Hang on to this DLL's instance handle.
  11.  
  12.     if (!controlsInit) {
  13.         controlsInit = TRUE;
  14.         InitCustomControls(hInstance);    // Initialize MAX's custom controls
  15.         InitCommonControls();            // Initialize Win95 controls
  16.     }
  17.             
  18.     return (TRUE);
  19. }
  20.  
  21. __declspec( dllexport ) const TCHAR* LibDescription()
  22. {
  23.     return GetString(IDS_LIBDESCRIPTION);
  24. }
  25.  
  26. //TODO: Must change this number when adding a new class
  27. __declspec( dllexport ) int LibNumberClasses()
  28. {
  29.     return 1;
  30. }
  31.  
  32. __declspec( dllexport ) ClassDesc* LibClassDesc(int i)
  33. {
  34.     switch(i) {
  35.         case 0: return GetlandscapeDesc();
  36.         default: return 0;
  37.     }
  38. }
  39.  
  40. __declspec( dllexport ) ULONG LibVersion()
  41. {
  42.     return VERSION_3DSMAX;
  43. }
  44.  
  45. TCHAR *GetString(int id)
  46. {
  47.     static TCHAR buf[256];
  48.     if (hInstance)
  49.         return LoadString(hInstance, id, buf, sizeof(buf)) ? buf : NULL;
  50.     return NULL;
  51. }
  52.  
  53. class landscapeClassDesc:public ClassDesc {
  54.     public:
  55.     int             IsPublic() {return 1;}
  56.     void *            Create(BOOL loading = FALSE) {return new landscape();}
  57.     const TCHAR *    ClassName() {return GetString(IDS_CLASS_NAME);}
  58.     SClass_ID        SuperClassID() {return GEOMOBJECT_CLASS_ID;}
  59.     Class_ID        ClassID() {return LANDSCAPE_CLASS_ID;}
  60.     const TCHAR*     Category() {return GetString(IDS_CATEGORY);}
  61.     void            ResetClassParams (BOOL fileReset);
  62. };
  63.  
  64. static landscapeClassDesc landscapeDesc;
  65. ClassDesc* GetlandscapeDesc() {return &landscapeDesc;}
  66.  
  67. void landscapeClassDesc::ResetClassParams (BOOL fileReset) 
  68. {
  69. }
  70.  
  71. //TODO: Add Parameter block indices for various parameters
  72. #define PB_SIZE                0
  73. #define PB_SEGX                1
  74. #define PB_SEGY                2
  75. #define PB_DISPLACEVALUE    3
  76. #define PB_MAPCOORD            4
  77. #define PB_MAPCOORDTILE        5
  78. #define PB_COLORZGRAD        6
  79.  
  80. //TODO: Add ParamUIDesc's for the various parameters
  81. static ParamUIDesc descParam[] = {
  82.     ParamUIDesc(
  83.         PB_SIZE,
  84.         EDITTYPE_FLOAT,
  85.         IDC_SIZE0,IDC_SIZE0SPIN,
  86.         1.0f,100000.0f,
  87.         1.0f),    
  88.     ParamUIDesc(
  89.         PB_SEGX,
  90.         EDITTYPE_INT,
  91.         IDC_SEGX,IDC_SEGXSPIN,
  92.         1,100000,
  93.         1),    
  94.     ParamUIDesc(
  95.         PB_SEGY,
  96.         EDITTYPE_INT,
  97.         IDC_SEGY,IDC_SEGYSPIN,
  98.         1,100000,
  99.         1),    
  100.     ParamUIDesc(
  101.         PB_DISPLACEVALUE,
  102.         EDITTYPE_FLOAT,
  103.         IDC_DISPLACEVALUE,IDC_DISPLACEVALUESPIN,
  104.         1.0f,10000.0f,
  105.         1.0f),    
  106.     ParamUIDesc(
  107.         PB_MAPCOORD,
  108.         TYPE_SINGLECHEKBOX,
  109.         IDC_MAPCOORD),    
  110.     ParamUIDesc(
  111.         PB_MAPCOORDTILE,
  112.         EDITTYPE_FLOAT,
  113.         IDC_MAPPINGTILE,IDC_MAPPINGTILESPIN,
  114.         1.0f,100.0f,
  115.         1.0f),    
  116.     ParamUIDesc(
  117.         PB_COLORZGRAD,
  118.         TYPE_SINGLECHEKBOX,
  119.         IDC_COLORZGRAD),    
  120.     };     
  121.  
  122. //TODO: Parameter descriptor length
  123. #define PARAMDESC_LENGTH 7
  124.  
  125. //TODO: Add ParamBlockDescID's for the various parameters
  126. static ParamBlockDescID descVer1[] = {
  127.     { TYPE_FLOAT, NULL, TRUE, 0 },
  128.     { TYPE_INT, NULL, TRUE, 0 },
  129.     { TYPE_INT, NULL, TRUE, 0 },
  130.     { TYPE_FLOAT, NULL, TRUE, 0 },
  131.     { TYPE_BOOL, NULL, TRUE, 0 },
  132.     { TYPE_FLOAT, NULL, TRUE, 0 },
  133.     { TYPE_BOOL, NULL, TRUE, 0 },
  134.     };
  135.  
  136. #define CURRENT_DESCRIPTOR descVer1
  137.  
  138. #define PBLOCK_LENGTH    7
  139.  
  140. #define CURRENT_VERSION    1
  141.  
  142. IObjParam *landscape::ip            = NULL;
  143. IParamMap *landscape::pmapParam    = NULL;
  144.  
  145. //--- landscape -------------------------------------------------------
  146.  
  147. landscape::landscape()
  148. {
  149.     strcpy(displacename,"None");
  150.     strcpy(colorname,"None");
  151.  
  152.     displacebmp=0;
  153.     colorbmp=0;
  154.  
  155.     pblock = CreateParameterBlock(
  156.                 CURRENT_DESCRIPTOR, 
  157.                 PBLOCK_LENGTH, 
  158.                 CURRENT_VERSION);
  159.     assert(pblock);
  160.     MakeRefByID(FOREVER, 0, pblock);
  161.     
  162.     pblock->SetValue(PB_SIZE,0, 0.0f);
  163.     pblock->SetValue(PB_SEGX,0, 16);
  164.     pblock->SetValue(PB_SEGY,0, 16);
  165.     pblock->SetValue(PB_DISPLACEVALUE,0, 10.0f);
  166.     pblock->SetValue(PB_MAPCOORD,0, 0);
  167.     pblock->SetValue(PB_MAPCOORDTILE,0, 4.0f);
  168.     pblock->SetValue(PB_COLORZGRAD,0, 0);
  169. }
  170.  
  171. landscape::~landscape()
  172. {
  173.     if (displacebmp)
  174.         displacebmp->DeleteThis();
  175.     if (colorbmp)
  176.         colorbmp->DeleteThis();
  177.     displacebmp=0;
  178.     colorbmp=0;
  179.     displacename[0]=0;
  180.     colorname[0]=0;
  181. }
  182.  
  183. #define DISPLACE_IMAGE_CHUNK 9110
  184. #define COLOR_IMAGE_CHUNK  9120
  185.  
  186. IOResult landscape::Load(ILoad *iload)
  187. {
  188.     ULONG nb;
  189.     IOResult res;
  190.     while (IO_OK==(res=iload->OpenChunk())) 
  191.     {
  192.         switch(iload->CurChunkID())  
  193.         {
  194.             case DISPLACE_IMAGE_CHUNK:
  195.                 res=iload->Read(displacename, iload->CurChunkLength(), &nb);
  196.                 break;
  197.             case COLOR_IMAGE_CHUNK:
  198.                 res=iload->Read(colorname, iload->CurChunkLength(), &nb);
  199.                 break;
  200.         }
  201.         iload->CloseChunk();
  202.         if (res!=IO_OK)
  203.             return res;
  204.     }
  205.     if (displacename[0])
  206.     {
  207.         BitmapInfo bi(displacename);
  208.         BMMRES status;
  209.         displacebmp=TheManager->Load(&bi,&status);
  210.         if (status!=BMMRES_SUCCESS)
  211.             displacename[0]=0;
  212.     }
  213.     if (colorname[0])
  214.     {
  215.         BitmapInfo bi(colorname);
  216.         BMMRES status;
  217.         colorbmp=TheManager->Load(&bi,&status);
  218.         if (status!=BMMRES_SUCCESS)
  219.             colorname[0]=0;
  220.     }
  221.     return IO_OK;
  222. }
  223.  
  224. IOResult landscape::Save(ISave *isave)
  225. {
  226.     ULONG nb;
  227.     
  228.     isave->BeginChunk(DISPLACE_IMAGE_CHUNK);
  229.     isave->Write(displacename, strlen(displacename)+1, &nb);
  230.     isave->EndChunk();
  231.  
  232.     isave->BeginChunk(COLOR_IMAGE_CHUNK);
  233.     isave->Write(colorname, strlen(colorname)+1, &nb);
  234.     isave->EndChunk();
  235.  
  236.     return IO_OK;
  237. }
  238.  
  239. class landscapeDlgProc : public ParamMapUserDlgProc {
  240.     public:
  241.         landscape *ls;
  242.         BOOL DlgProc(TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);
  243.         void DeleteThis() {}
  244.     };
  245.  
  246. static landscapeDlgProc landscapeProc;
  247.  
  248. BOOL landscapeDlgProc::DlgProc(
  249.         TimeValue t,IParamMap *map,
  250.         HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
  251. {
  252.     switch(msg)
  253.     {
  254.     case WM_COMMAND:
  255.         if (wParam==IDC_DISPLACEIMAGEBUT)
  256.         {
  257.             BitmapInfo bi;
  258.             if (ls->displacebmp)
  259.                 ls->displacebmp->DeleteThis();
  260.             ls->displacebmp=0;
  261.             strcpy(ls->displacename,"None");
  262.             if (TheManager->SelectFileInput(&bi,hWnd,"Select displace image"))
  263.                 {
  264.                 BMMRES status;
  265.                 ls->displacebmp=TheManager->Load(&bi,&status);
  266.                 if (status==BMMRES_SUCCESS)
  267.                     strcpy(ls->displacename,bi.Filename());
  268.                 }
  269.             SetDlgItemText(hWnd,IDC_DISPLACEIMAGEBUT,ls->displacename);
  270.             float size;
  271.             ls->pblock->GetValue(PB_SIZE,ls->ip->GetTime(),size,FOREVER);
  272.             ls->pblock->SetValue(PB_SIZE,0, size);
  273.         }
  274.         else if (wParam==IDC_TEXTUREIMAGEBUT)
  275.         {
  276.             BitmapInfo bi;
  277.             if (ls->colorbmp)
  278.                 ls->colorbmp->DeleteThis();
  279.             ls->colorbmp=0;
  280.             strcpy(ls->colorname,"None");
  281.             if (TheManager->SelectFileInput(&bi,hWnd,"Select texture image"))
  282.                 {
  283.                 BMMRES status;
  284.                 ls->colorbmp=TheManager->Load(&bi,&status);
  285.                 if (status==BMMRES_SUCCESS)
  286.                     strcpy(ls->colorname,bi.Filename());
  287.                 }
  288.             SetDlgItemText(hWnd,IDC_TEXTUREIMAGEBUT,ls->colorname);
  289.             float size;
  290.             ls->pblock->GetValue(PB_SIZE,ls->ip->GetTime(),size,FOREVER);
  291.             ls->pblock->SetValue(PB_SIZE,0, size);
  292.         }
  293.         break;
  294.     }
  295.     return FALSE;
  296. }
  297.  
  298. void landscape::BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev)
  299. {
  300.     this->ip = ip;
  301.     landscapeProc.ls=this;
  302.     SimpleObject::BeginEditParams(ip,flags,prev);
  303.  
  304.     if(pmapParam) {
  305.         pmapParam->SetParamBlock(pblock);
  306.     } else {
  307.         pmapParam = CreateCPParamMap(
  308.             descParam, PARAMDESC_LENGTH,
  309.             pblock, 
  310.             ip, 
  311.             hInstance, 
  312.             MAKEINTRESOURCE(IDD_PANEL),
  313.             GetString(IDS_PARAMS), 
  314.             0);
  315.     }
  316.     pmapParam->SetUserDlgProc(&landscapeProc);
  317.     
  318.     HWND hWnd=pmapParam->GetHWnd();
  319.     SetDlgItemText(hWnd,IDC_DISPLACEIMAGEBUT,displacename);
  320.     SetDlgItemText(hWnd,IDC_TEXTUREIMAGEBUT,colorname);
  321. }
  322.  
  323. void landscape::EndEditParams( IObjParam *ip, ULONG flags,Animatable *next )
  324. {
  325.     SimpleObject::EndEditParams(ip,flags,next);
  326.     if (flags&END_EDIT_REMOVEUI ) {
  327.         DestroyCPParamMap(pmapParam);
  328.         pmapParam  = NULL;
  329.     }
  330.     this->ip = NULL;
  331. }
  332.  
  333. BOOL landscape::HasUVW() 
  334. { 
  335.     BOOL mapcoord;
  336.     pblock->GetValue(PB_MAPCOORD,0,mapcoord,FOREVER);
  337.     return mapcoord; 
  338. }
  339.  
  340. void landscape::SetGenUVW(BOOL sw) 
  341. {  
  342.     if (sw==HasUVW()) return;
  343.     pblock->SetValue(PB_MAPCOORD,0, sw);
  344. }
  345.  
  346. class landscapeCreateCallBack : public CreateMouseCallBack {
  347.     IPoint2 sp0;        //First point in screen coordinates
  348.     landscape *ob;        //Pointer to the object 
  349.     Point3 p0;            //First point in world coordinates
  350. public:    
  351.     int proc( ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat);
  352.     void SetObj(landscape *obj) {ob = obj;}
  353. };
  354.  
  355. int landscapeCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
  356. {
  357.     if (msg == MOUSE_FREEMOVE)
  358.         vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
  359.     else
  360.     if (msg==MOUSE_POINT)
  361.         {
  362.         if (point==0)
  363.             {
  364.             ob->suspendSnap = TRUE;
  365.             sp0 = m;
  366.             p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
  367.             mat.SetTrans(p0);
  368.             }
  369.         else 
  370.             {
  371.             ob->suspendSnap = FALSE;
  372.             return Length(sp0 - m)<3?CREATE_ABORT:CREATE_STOP;
  373.             }
  374.         }
  375.     else if (msg==MOUSE_MOVE) 
  376.         {
  377.         float size=Length(p0 - vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
  378.         ob->pblock->SetValue(PB_SIZE,0, size);
  379.         ob->pmapParam->Invalidate();
  380.         } 
  381.     else 
  382.         if (msg == MOUSE_ABORT) 
  383.             return CREATE_ABORT;
  384.  
  385.     return CREATE_CONTINUE;
  386. }
  387.  
  388. static landscapeCreateCallBack landscapeCreateCB;
  389.  
  390. CreateMouseCallBack* landscape::GetCreateMouseCallBack() 
  391. {
  392.     landscapeCreateCB.SetObj(this);
  393.     return(&landscapeCreateCB);
  394. }
  395.  
  396. void landscape::BuildMesh(TimeValue t)
  397. {
  398.     int nv,nf,ncvx,ncvy,x,y,i,segx,segy;
  399.     Point3 p;
  400.     float dx,dy,size,displacevalue,tile,maxdz=0;
  401.     BOOL mapcoord;
  402.     BOOL colorzgrad;
  403.     
  404.     ivalid = FOREVER;
  405.     pblock->GetValue(PB_SIZE,t,size,FOREVER);
  406.     pblock->GetValue(PB_SEGX,t,segx,FOREVER);
  407.     pblock->GetValue(PB_SEGY,t,segy,FOREVER);
  408.     pblock->GetValue(PB_DISPLACEVALUE,t,displacevalue,FOREVER);
  409.     pblock->GetValue(PB_MAPCOORD,t,mapcoord,FOREVER);
  410.     pblock->GetValue(PB_MAPCOORDTILE,t,tile,FOREVER);
  411.     pblock->GetValue(PB_COLORZGRAD,t,colorzgrad,FOREVER);
  412.     
  413.     ncvx=segx+1;
  414.     ncvy=segy+1;
  415.     nv=ncvx*ncvy;
  416.     nf=segx*2*segy;
  417.  
  418.     dx=size/(segx/2.0f);
  419.     dy=size/(segy/2.0f);
  420.  
  421.     mesh.setNumVerts(nv);
  422.     mesh.setNumFaces(nf);
  423.  
  424.     for( i=0,y=0;y<ncvy;y++ )
  425.         for( x=0;x<ncvx;x++,i++ )
  426.         {
  427.         p.x=-size+dx*x;
  428.         p.y=-size+dy*y;
  429.         p.z=0;
  430.         mesh.setVert(i,p);
  431.         }
  432.     for( i=0,y=0;y<segy;y++ )
  433.         for( x=0;x<segx;x++ )
  434.         {
  435.             mesh.faces[i].v[0]=y*ncvx+x;
  436.             mesh.faces[i].v[1]=y*ncvx+x+1;
  437.             mesh.faces[i].v[2]=(y+1)*ncvx+x;
  438.             mesh.faces[i].flags=EDGE_A|EDGE_C;
  439.             mesh.faces[i].smGroup=1;
  440.             i++;
  441.  
  442.             mesh.faces[i].v[0]=y*ncvx+x+1;
  443.             mesh.faces[i].v[1]=(y+1)*ncvx+x+1;
  444.             mesh.faces[i].v[2]=(y+1)*ncvx+x;
  445.             mesh.faces[i].flags=EDGE_A|EDGE_B;
  446.             mesh.faces[i].smGroup=1;
  447.             i++;
  448.         }
  449.     
  450.     if (displacebmp)
  451.     {
  452.     int wd,hd,c;
  453.     float dz;
  454.     wd=displacebmp->Width();
  455.     hd=displacebmp->Height();
  456.     BMM_Color_64 *ptr=new BMM_Color_64[wd]; 
  457.  
  458.     for( i=0,y=0;y<ncvy;y++ )
  459.         {
  460.         displacebmp->GetLinearPixels(0,y*(hd-1)/(ncvy-1),wd,ptr);
  461.         for( x=0;x<ncvx;x++,i++ )
  462.             {
  463.             c=  (int)ptr[x*(wd-1)/(ncvx-1)].r+
  464.                 (int)ptr[x*(wd-1)/(ncvx-1)].g+
  465.                 (int)ptr[x*(wd-1)/(ncvx-1)].b;
  466.             dz= displacevalue*(c/(float)0xffff);
  467.             mesh.verts[i].z+=dz;
  468.             if (dz>maxdz)
  469.                 maxdz=dz;
  470.             }
  471.         }
  472.  
  473.     delete ptr;
  474.     }
  475.  
  476.     if (colorbmp)
  477.     {
  478.     int wt,ht,c;
  479.     BMM_Color_64 *ptr=0;
  480.     wt=colorbmp->Width();
  481.     ht=colorbmp->Height();
  482.     ptr=new BMM_Color_64[wt];
  483.     
  484.     mesh.setNumVertCol(nv);
  485.     mesh.setNumVCFaces(nf);
  486.  
  487.     for( i=0;i<nf;i++ )
  488.         for( c=0;c<3;c++ )
  489.             mesh.vcFace[i].t[c]=mesh.faces[i].v[c];
  490.  
  491.     if (colorzgrad)
  492.         {
  493.             if (maxdz>0)
  494.             {
  495.             colorbmp->GetLinearPixels(0,0,wt,ptr);
  496.             for( i=0,y=0;y<ncvy;y++ )
  497.                 {
  498.                 for( x=0;x<ncvx;x++,i++ )
  499.                     {
  500.                     c=(int)(mesh.verts[i].z/maxdz*(ht-1));
  501.                     mesh.vertCol[i].x=(ptr[c].r/(float)0xffff);
  502.                     mesh.vertCol[i].y=(ptr[c].g/(float)0xffff);
  503.                     mesh.vertCol[i].z=(ptr[c].b/(float)0xffff);
  504.                     }
  505.                 }
  506.             }
  507.         }
  508.     else 
  509.         for( i=0,y=0;y<ncvy;y++ )
  510.             {
  511.             colorbmp->GetLinearPixels(0,y*(ht-1)/(ncvy-1),wt,ptr);
  512.             for( x=0;x<ncvx;x++,i++ )
  513.                 {
  514.                 mesh.vertCol[i].x=(ptr[x*(wt-1)/(ncvx-1)].r/(float)0xffff);
  515.                 mesh.vertCol[i].y=(ptr[x*(wt-1)/(ncvx-1)].g/(float)0xffff);
  516.                 mesh.vertCol[i].z=(ptr[x*(wt-1)/(ncvx-1)].b/(float)0xffff);
  517.                 }
  518.             }
  519.  
  520.     delete ptr;
  521.     }
  522.     else 
  523.     {
  524.     mesh.setNumVertCol(nv);
  525.     mesh.setNumVCFaces(nf);
  526.     int c;
  527.     for( i=0;i<nf;i++ )
  528.         for( c=0;c<3;c++ )
  529.             mesh.vcFace[i].t[c]=mesh.faces[i].v[c];
  530.     for( i=0;i<nv;i++ )
  531.         {
  532.         mesh.vertCol[i].x=1.0f;
  533.         mesh.vertCol[i].y=1.0f;
  534.         mesh.vertCol[i].z=1.0f;
  535.         }
  536.     }
  537.  
  538.     if (mapcoord)
  539.     {
  540.     mesh.setNumTVerts(nv);
  541.     mesh.setNumTVFaces(nf);
  542.     for( i=0,y=0;y<ncvy;y++ )
  543.         for( x=0;x<ncvx;x++,i++ )
  544.             mesh.setTVert(i,(float)x/ncvx*tile,(float)y/ncvy*tile,0);
  545.     for( i=0;i<nf;i++ )
  546.         for( x=0;x<3;x++ )
  547.             mesh.tvFace[i].t[x]=mesh.faces[i].v[x];
  548.     }
  549.  
  550.     mesh.InvalidateGeomCache();
  551.     mesh.InvalidateTopologyCache();
  552.     mesh.BuildStripsAndEdges();
  553. }
  554.  
  555. BOOL landscape::OKtoDisplay(TimeValue t) 
  556. {
  557.     float size;
  558.     pblock->GetValue(PB_SIZE,t,size,FOREVER);
  559.     if (size==0.0f) return FALSE;
  560.     else return TRUE;
  561. }
  562.  
  563. void landscape::InvalidateUI() 
  564. {
  565.     if (pmapParam) pmapParam->Invalidate();
  566. }
  567.  
  568. ParamDimension *landscape::GetParameterDim(int pbIndex) 
  569. {
  570.     return defaultDim;
  571. }
  572.  
  573. TSTR landscape::GetParameterName(int pbIndex) 
  574. {
  575.     return GetString(IDS_PARAMS);
  576. }
  577.  
  578. BOOL landscape::SetValue(int i, TimeValue t, int v) 
  579. {
  580.     return TRUE;
  581. }
  582.  
  583. BOOL landscape::SetValue(int i, TimeValue t, float v)
  584. {
  585.     return TRUE;
  586. }
  587.  
  588. BOOL landscape::SetValue(int i, TimeValue t, Point3 &v) 
  589. {
  590.     return TRUE;
  591. }
  592.  
  593. BOOL landscape::GetValue(int i, TimeValue t, int &v, Interval &ivalid) 
  594. {
  595.     return TRUE;
  596. }
  597.  
  598. BOOL landscape::GetValue(int i, TimeValue t, float &v, Interval &ivalid) 
  599. {
  600.     return TRUE;
  601. }
  602.  
  603. BOOL landscape::GetValue(int i, TimeValue t, Point3 &v, Interval &ivalid) 
  604. {    
  605.     return TRUE;
  606. }
  607.  
  608. Object* landscape::ConvertToType(TimeValue t, Class_ID obtype)
  609. {
  610.     return SimpleObject::ConvertToType(t,obtype);
  611. }
  612.  
  613. int landscape::CanConvertToType(Class_ID obtype)
  614. {
  615.     if (obtype==defObjectClassID ||
  616.         obtype==triObjectClassID) {
  617.         return 1;
  618.     } else {        
  619.     return SimpleObject::CanConvertToType(obtype);
  620.         }
  621. }
  622.  
  623. int landscape::IntersectRay(
  624.         TimeValue t, Ray& ray, float& at, Point3& norm)
  625. {
  626.     return SimpleObject::IntersectRay(t,ray,at,norm);
  627. }
  628.  
  629. void landscape::GetCollapseTypes(Tab<Class_ID> &clist,Tab<TSTR*> &nlist)
  630. {
  631.     Object::GetCollapseTypes(clist, nlist);
  632. }
  633.  
  634. RefTargetHandle landscape::Clone(RemapDir& remap) 
  635. {
  636.     landscape* newob = new landscape();    
  637.     newob->ReplaceReference(0,pblock->Clone(remap));
  638.     newob->ivalid.SetEmpty();
  639.     return(newob);
  640. }
  641.